{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il s’agit de repérer les données nécessaires voire indispensables à la\n",
    "résolution. Ces données peuvent être:\n",
    "\n",
    "-   numériques,\n",
    "-   ou sous forme de textes (on dit souvent chaînes de caractères),\n",
    "-   ou de type logique (à deux valeurs possibles, vrai ou faux).\n",
    "\n",
    "Pour affecter une valeur à une variable en python, la syntaxe est de la forme:\n",
    "\n",
    "```\n",
    "nom = valeur\n",
    "```\n",
    "\n",
    "<dl>\n",
    "<dt>Affectation</dt>\n",
    "<dd>Dans un programme, une affectation donne une valeur à une variable, elle est de la forme <code>v = e</code> avec `v` une variable et `e` une expression.\n",
    "</dd>\n",
    "</dl>\n",
    "\n",
    "Valeurs numériques\n",
    "==================\n",
    "\n",
    "Python distingue les entiers(integers), des nombres à\n",
    "virgule(floating-point) par l'ajout d'une virgule:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 <class 'int'> 1.0 <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "# <!-- collapse=True -->\n",
    "a = 1\n",
    "b = 1.0\n",
    "\n",
    "print(a, type(a), b, type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mais il implémente aussi des nombres plus exotiques tels que les\n",
    "décimaux, les fractions ou encore les nombres complexes\n",
    "\n",
    "Chaînes de caractères\n",
    "=====================\n",
    "\n",
    "En python3, il existe deux grands types de chaînes de caractères, les\n",
    "strings, et les bytes. Les strings sont simplement entourées par des\n",
    "guillemets simples ou doubles.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mon texte <class 'str'> Mon deuxième texte <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "# <!-- collapse=False -->\n",
    "a = 'Mon texte'\n",
    "b = \"Mon deuxième texte\"\n",
    "\n",
    "print(a, type(a), b, type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les bytes sont précédées de la lettre b, il s'agit de texte brut utilisé\n",
    "par la machine mais pas toujours lisible par un humain.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'Mon texte' <class 'bytes'>\n"
     ]
    }
   ],
   "source": [
    "a = b'Mon texte'\n",
    "print(a, type(a))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On ne peut représenter simplement que certains caractères(les caractères\n",
    "ASCII), les caractères accentués ne peuvent être écrits directement.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "bytes can only contain ASCII literal characters. (<ipython-input-5-b0bf0ef2715d>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-5-b0bf0ef2715d>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    b = b'Mon deuxième texte'\u001b[0m\n\u001b[1;37m       ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m bytes can only contain ASCII literal characters.\n"
     ]
    }
   ],
   "source": [
    "b = b'Mon deuxième texte'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un encodage autre que le ASCII doit être utilisé pour ces caractères,\n",
    "comme par exemple le UTF-8 qui est un codage sur huit bits très répandu.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'Mon deuxi\\xc3\\xa8me texte'\n",
      "Mon deuxième texte\n"
     ]
    }
   ],
   "source": [
    "b = b'Mon deuxi\\xc3\\xa8me texte'\n",
    "print(b)\n",
    "print(b.decode('utf-8'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Valeurs logiques\n",
    "================\n",
    "\n",
    "On les appelle les booléens, il ne peuvent avoir que deux valeurs:\n",
    "\n",
    "-   VRAI ou FAUX: True ou False en anglais;\n",
    "-   1 ou 0.\n",
    "\n",
    "On les utilise pour réaliser des tests.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False, False, True, True, False)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 < 2, 1 > 2, 2 == 10, 2 >= 1.9, 2 == 2, 2 != 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi les utiliser pour savoir si une variable existe.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi combiner plusieurs tests avec les opérateurs booléens `and`, `or` et `not`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 < 2 or 2 < 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 < 2 and 2 < 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not(1 < 2 and 2 < 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#Listes et dictionnaires\n",
    "\n",
    "Souvent les données pertinentes doivent être agencées sous une forme\n",
    "plus vaste, comme par exemple des listes où on peut ranger de façon ordonnée *plusieurs valeurs*.\n",
    "\n",
    "##Listes\n",
    "\n",
    "\n",
    "Les listes sont des collections *ordonnées de valeurs*, elles sont\n",
    "entourées par des crochets `[]`, leurs éléments sont séparés par des\n",
    "virgules.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [ 1, 'deux' , 3]\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut facilement accéder à la longueur de la liste grace à la fonction\n",
    "`len` et à chacun de ces éléments grâce à leur index *(Attention le\n",
    "premier élement à l'index 0)*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(a)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 3)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0], a[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut inversement connaître l'indice correspondant à une valeur grâce à l'attribut `index`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1, 2)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.index(1), a.index('deux'), a.index(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##Dictionnaires\n",
    "\n",
    "Dans un dictionnaire les valeurs de la collection ne sont pas repéré par\n",
    "un index, mais par une *clé*. Les dictionnaires sont entourés d'accolades `{}`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = { 'nom': 'Doe' , 'prenom': 'John', 'age': 77 }\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour accéder aux éléments du dictionnaire, il suffit d'appeler la clé\n",
    "correspondante, d'autres part la fonction `len` est égalemnt disponible.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Doe', 77)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a['nom'], a['age']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##Modification des listes et dictionnaires\n",
    "\n",
    "Les listes et dictionnaires sont des objets **mutables**, c'est à dire que l'on peut modifier leur contenu sans créer un nouvel objet. On dit qu'il s'agit de données [non-persistantes](http://fr.wikipedia.org/wiki/Persistance_%28informatique%29).\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valeurs initiales:\n",
      " [1, 'deux', 3] {'age': 77, 'nom': 'Doe', 'prenom': 'John'}\n",
      "Modification des valeurs par assignation:\n",
      " [1, 2, 3] {'age': 17, 'nom': 'Doe', 'prenom': 'John'}\n",
      "Ajout d'éléments:\n",
      " [1, 2, 3, 4] {'age': 17, 'nom': 'Doe', 'nationalité': 'française', 'prenom': 'John'}\n",
      "Suppression d'éléments:\n",
      " [2, 3, 4] {'nom': 'Doe', 'nationalité': 'française', 'prenom': 'John'}\n"
     ]
    }
   ],
   "source": [
    "# Valeurs initiales\n",
    "liste = [ 1, 'deux' , 3]\n",
    "dict = { 'nom': 'Doe' , 'prenom': 'John', 'age': 77 }\n",
    "print(\"Valeurs initiales:\\n\", liste, dict)\n",
    "\n",
    "# Modification des valeurs par assignation\n",
    "liste[1] = 2\n",
    "dict['age'] = 17\n",
    "\n",
    "print(\"Modification des valeurs par assignation:\\n\", liste, dict)\n",
    "\n",
    "# Ajout d'éléments\n",
    "liste.append(4)\n",
    "dict['nationalité'] = 'française'\n",
    "\n",
    "print(\"Ajout d'éléments:\\n\", liste, dict)\n",
    "\n",
    "# Suppression d'éléments\n",
    "liste.pop(0)\n",
    "dict.pop('age')\n",
    "\n",
    "print(\"Suppression d'éléments:\\n\", liste, dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si on a besoin de modifier une liste ou un dictionnaire, mais que l'on veut garder une trace des objets initiaux, il faut commencer par en créer une **copie**, il ne suffit pas de créer une variable suplémentaire sans quoi cette variable serait elle aussi modifiée si l'objet initial changeait: l'assignation est dite par **référence** dans ce cas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valeurs initiales:\n",
      " [1, 'deux', 3]\n",
      "Modification de la liste L:\n",
      "La liste L a bien, été modifiée: [1, 2, 3]\n",
      "La liste L_ref a aussi été modifiée car il s'agit juste d'une référence vers la liste L: [1, 2, 3]\n",
      "La copie L_copie n'a pas été modifiée: [1, 'deux', 3]\n"
     ]
    }
   ],
   "source": [
    "# Valeurs initiales\n",
    "L = [ 1, 'deux' , 3]\n",
    "print(\"Valeurs initiales:\\n\", L)\n",
    "\n",
    "# Création d'une référencxe à la liste par simple assignation\n",
    "L_ref = L\n",
    "\n",
    "# Création d'une copie de la liste\n",
    "L_copie = list(L)\n",
    "\n",
    "# Modification de la liste initiale\n",
    "L[1] = 2\n",
    "\n",
    "print(\"Modification de la liste L:\")\n",
    "print(\"La liste L a bien, été modifiée:\", L)\n",
    "print(\"La liste L_ref a aussi été modifiée car il s'agit juste d'une référence vers la liste L:\", L_ref)\n",
    "print(\"La copie L_copie n'a pas été modifiée:\", L_copie)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entrée des données\n",
    "==================\n",
    "\n",
    "Dans cette phase peut aussi figurer ce qu’on appelle l’entrée des\n",
    "données, qui peut se manifester par la saisie de caractères ou de\n",
    "nombres sur le clavier, ou la lecture de la position du pointeur de la\n",
    "souris, ou encore par la lecture d’un fichier contenant ces nombres ou\n",
    "caractères.\n",
    "\n",
    "Il s’agit aussi de repérer les résultats intermédiaires qu’il est bon de\n",
    "mémoriser pour la suite car indispensables au traitement.\n",
    "\n",
    "Il est parfois utile d’utiliser des variables auxiliaires pour ne pas\n",
    "perturber les données initiales.\n",
    "\n",
    "Entrée des données au clavier\n",
    "-----------------------------\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entrer la valeur du chiffre souhaité: 7\n"
     ]
    }
   ],
   "source": [
    "chiffre = input(\"Entrer la valeur du chiffre souhaité: \")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "print(chiffre)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attention cependant, cette valeur est une chaîne de caractère, et les opérations sont celles des `string`s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'7777777777'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(type(chiffre))\n",
    "chiffre*10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il convient de la convertir un nombre entier ou flottant avant d'utiliser la valeur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "70"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chiffre = int(chiffre)\n",
    "10*chiffre"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lecture d'un fichier\n",
    "--------------------\n",
    "\n",
    "Voici par exemple comment ouvrir et lire un fichier appelé `lorem.txt`\n",
    "contenu dans le répértoire `data` du dossier courant.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod\\ntempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At\\nvero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren,\\nno sea takimata sanctus est Lorem ipsum dolor sit amet.\\n'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fichier = open('data/lorem.txt')\n",
    "fichier.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans la sortie précédente, les caractères `\\n` représentent les sauts de\n",
    "ligne, on peut aussi lire le fichier ligne par ligne."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod\\n'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fichier = open('data/lorem.txt')\n",
    "fichier.readline()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.4.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
